home *** CD-ROM | disk | FTP | other *** search
/ All for Cell Phones: Sony Ericsson / Sony-Ericsson 2004.iso / Java / Eval / eval.jar / eval / Result.class (.txt) < prev    next >
Encoding:
Java Class File  |  2002-06-13  |  5.6 KB  |  326 lines
  1. package eval;
  2.  
  3. import java.util.Vector;
  4.  
  5. class Result {
  6.    public static final int TYPE_ERROR = 100;
  7.    public static final int TYPE_LONG = 1;
  8.    public static final int TYPE_BCD = 2;
  9.    public static final int OPER_ADD = 1;
  10.    public static final int OPER_SUB = 2;
  11.    public static final int OPER_MUL = 3;
  12.    public static final int OPER_DIV = 4;
  13.    public int type;
  14.    // $FF: renamed from: ll long
  15.    public long field_0;
  16.    public MyDecimal bcd;
  17.    private static StringBuffer strBuf;
  18.    private static int nBuf;
  19.    protected static Vector vars = new Vector();
  20.  
  21.    public Result() {
  22.       this.type = 1;
  23.       this.field_0 = 0L;
  24.    }
  25.  
  26.    public Result(int var1, long var2, MyDecimal var4) {
  27.       this.type = var1;
  28.       this.field_0 = var2;
  29.       this.bcd = var4;
  30.    }
  31.  
  32.    public Result(long var1) {
  33.       this.field_0 = var1;
  34.       this.type = 1;
  35.    }
  36.  
  37.    public Result(MyDecimal var1) {
  38.       this.type = 2;
  39.       this.bcd = new MyDecimal(var1);
  40.    }
  41.  
  42.    public Result(Result var1) {
  43.       this.type = var1.type;
  44.       this.field_0 = var1.field_0;
  45.       this.bcd = new MyDecimal(var1.bcd);
  46.    }
  47.  
  48.    public Result(String var1) throws MyDecimalException {
  49.       this.type = 2;
  50.       this.bcd = new MyDecimal(var1);
  51.    }
  52.  
  53.    public static Result Evaluate(String var0) throws BadFormulaException {
  54.       int var2;
  55.       if ((var2 = var0.indexOf(61)) > 0) {
  56.          String var3 = var0.substring(0, var2);
  57.          if (!validName(var3)) {
  58.             throw new BadFormulaException("Invalid variable name <" + var3 + ">");
  59.          } else {
  60.             Result var5 = Evaluate(var0.substring(var2 + 1));
  61.             Variable var4 = findVar(var3);
  62.             if (var4 != null) {
  63.                if (var4.persistent) {
  64.                   throw new BadFormulaException("System constant cannot be modified");
  65.                }
  66.  
  67.                var4.val = var5;
  68.             }
  69.  
  70.             addVar(new Variable(var3, var5, false));
  71.             return var5;
  72.          }
  73.       } else {
  74.          strBuf = new StringBuffer(var0);
  75.          strBuf.append('\u0000');
  76.          nBuf = 0;
  77.          Result var1 = fplus();
  78.          if (get1() != 0) {
  79.             throw new BadFormulaException("Bad expression");
  80.          } else {
  81.             strBuf = null;
  82.             return var1;
  83.          }
  84.       }
  85.    }
  86.  
  87.    public static void addVar(Variable var0) {
  88.       vars.addElement(var0);
  89.    }
  90.  
  91.    private static Result fconst() throws BadFormulaException {
  92.       if (isLetter(strBuf.charAt(nBuf))) {
  93.          return ffunc();
  94.       } else {
  95.          String var2 = "bad formula (expected a constant)";
  96.          StringBuffer var3 = new StringBuffer("");
  97.  
  98.          char var0;
  99.          while((var0 = strBuf.charAt(nBuf++)) >= '0' && var0 <= '9' || var0 == '.') {
  100.             var3.append(var0);
  101.          }
  102.  
  103.          --nBuf;
  104.          if (var3.length() <= 0) {
  105.             throw new BadFormulaException(var2);
  106.          } else {
  107.             try {
  108.                Result var1 = new Result(var3.toString());
  109.                return var1;
  110.             } catch (MyDecimalException var4) {
  111.                throw new BadFormulaException(var2);
  112.             }
  113.          }
  114.       }
  115.    }
  116.  
  117.    private static Result ffunc() throws BadFormulaException {
  118.       StringBuffer var1 = new StringBuffer("");
  119.  
  120.       char var0;
  121.       while(isLetter(var0 = strBuf.charAt(nBuf++)) || isDigit(var0)) {
  122.          var1.append(var0);
  123.       }
  124.  
  125.       String var2 = var1.toString();
  126.       if (var0 == '(') {
  127.          Result var4 = fplus();
  128.          if (get1() != ')') {
  129.             throw new BadFormulaException("missing ')' in function");
  130.          } else {
  131.             if (var2.compareTo("sin") == 0) {
  132.                var4.bcd = var4.bcd.sin();
  133.             } else {
  134.                if (var2.compareTo("cos") != 0) {
  135.                   throw new BadFormulaException("unknown function " + var2 + "()");
  136.                }
  137.  
  138.                var4.bcd = var4.bcd.cos();
  139.             }
  140.  
  141.             return var4;
  142.          }
  143.       } else {
  144.          --nBuf;
  145.          Variable var3 = findVar(var2);
  146.          if (var3 == null) {
  147.             throw new BadFormulaException("unknown variable name <" + var2 + ">");
  148.          } else {
  149.             return new Result(var3.val);
  150.          }
  151.       }
  152.    }
  153.  
  154.    public static Variable findVar(String var0) {
  155.       var0 = var0.toLowerCase();
  156.  
  157.       for(int var1 = 0; var1 < vars.size(); ++var1) {
  158.          Variable var2 = (Variable)vars.elementAt(var1);
  159.          if (var0.compareTo(var2.name) == 0) {
  160.             return var2;
  161.          }
  162.       }
  163.  
  164.       return null;
  165.    }
  166.  
  167.    private static Result fminus() throws BadFormulaException {
  168.       if (get1() == '-') {
  169.          Result var0 = fparent();
  170.          if (var0.type == 2) {
  171.             var0.bcd.reverse();
  172.          } else if (var0.type == 1) {
  173.             var0.field_0 = -var0.field_0;
  174.          }
  175.  
  176.          return var0;
  177.       } else {
  178.          unget1();
  179.          return fconst();
  180.       }
  181.    }
  182.  
  183.    private static Result fmult() throws BadFormulaException {
  184.       Result var0;
  185.       Result var1;
  186.       char var2;
  187.       for(var0 = fparent(); (var2 = get1()) == '*' || var2 == '/'; var0 = operation(var2 == '*' ? 3 : 4, var0, var1)) {
  188.          var1 = fparent();
  189.       }
  190.  
  191.       unget1();
  192.       return var0;
  193.    }
  194.  
  195.    private static Result fparent() throws BadFormulaException {
  196.       if (get1() == '(') {
  197.          Result var0 = fplus();
  198.          if (get1() != ')') {
  199.             throw new BadFormulaException("missing ')'");
  200.          } else {
  201.             return var0;
  202.          }
  203.       } else {
  204.          unget1();
  205.          return fminus();
  206.       }
  207.    }
  208.  
  209.    private static Result fplus() throws BadFormulaException {
  210.       Result var0;
  211.       Result var1;
  212.       char var2;
  213.       for(var0 = fmult(); (var2 = get1()) == '+' || var2 == '-'; var0 = operation(var2 == '+' ? 1 : 2, var0, var1)) {
  214.          var1 = fmult();
  215.       }
  216.  
  217.       unget1();
  218.       return var0;
  219.    }
  220.  
  221.    private static char get1() throws BadFormulaException {
  222.       char var0;
  223.       while((var0 = strBuf.charAt(nBuf++)) == ' ' || var0 == '\t' || var0 == '\n') {
  224.       }
  225.  
  226.       return var0;
  227.    }
  228.  
  229.    private static boolean isDigit(char var0) {
  230.       return var0 >= '0' && var0 <= '9';
  231.    }
  232.  
  233.    private static boolean isLetter(char var0) {
  234.       return var0 >= 'a' && var0 <= 'z' || var0 >= 'A' && var0 <= 'Z' || var0 >= '_';
  235.    }
  236.  
  237.    public static int numberOfVars(boolean var0) {
  238.       int var1 = 0;
  239.  
  240.       for(int var2 = 0; var2 < vars.size(); ++var2) {
  241.          Variable var3 = (Variable)vars.elementAt(var2);
  242.          if (var3.persistent == var0) {
  243.             ++var1;
  244.          }
  245.       }
  246.  
  247.       return var1;
  248.    }
  249.  
  250.    public static Result operation(int var0, Result var1, Result var2) throws BadFormulaException {
  251.       Result var3 = new Result();
  252.       int var4 = var1.toMaxType(var2.toMaxType(var1.type));
  253.       switch (var0) {
  254.          case 1:
  255.             if (var4 == 1) {
  256.                var3.field_0 = var1.field_0 + var2.field_0;
  257.             } else {
  258.                var3.bcd = var1.bcd.add(var2.bcd);
  259.             }
  260.             break;
  261.          case 2:
  262.             if (var4 == 1) {
  263.                var3.field_0 = var1.field_0 - var2.field_0;
  264.             } else {
  265.                var3.bcd = var1.bcd.subtract(var2.bcd);
  266.             }
  267.             break;
  268.          case 3:
  269.             if (var4 == 1) {
  270.                var3.field_0 = var1.field_0 * var2.field_0;
  271.             } else {
  272.                var3.bcd = var1.bcd.multiply(var2.bcd);
  273.             }
  274.             break;
  275.          case 4:
  276.             if (var4 == 1) {
  277.                var1.field_0 /= var2.field_0;
  278.             } else {
  279.                try {
  280.                   var3.bcd = var1.bcd.divide(var2.bcd);
  281.                } catch (MyDecimalException var6) {
  282.                   throw new BadFormulaException(((Throwable)var6).getMessage());
  283.                }
  284.             }
  285.       }
  286.  
  287.       var3.type = var4;
  288.       return var3;
  289.    }
  290.  
  291.    private int toMaxType(int var1) {
  292.       return this.type;
  293.    }
  294.  
  295.    public String toString() {
  296.       if (this.type == 1) {
  297.          return Long.toString(this.field_0);
  298.       } else {
  299.          String var1 = this.bcd.toString();
  300.          return var1;
  301.       }
  302.    }
  303.  
  304.    private static void unget1() {
  305.       --nBuf;
  306.    }
  307.  
  308.    private static boolean validName(String var0) {
  309.       int var2 = var0.length();
  310.       if (var2 <= 0) {
  311.          return false;
  312.       } else if (!isLetter(var0.charAt(0))) {
  313.          return false;
  314.       } else {
  315.          for(int var3 = 1; var3 < var2; ++var3) {
  316.             char var1;
  317.             if (!isLetter(var1 = var0.charAt(var3)) && !isDigit(var1)) {
  318.                return false;
  319.             }
  320.          }
  321.  
  322.          return true;
  323.       }
  324.    }
  325. }
  326.